Importing the Data

Great. Now we need to get our data into our network. Put the nodes.csv and edges.csv files that I have shared with you into the working directory where you should be keeping this notebook file (or set the working directory to the write place in the Session menu).

We will now load the nodes into a nodes data frame and edges into an edges data frame. The “head” command with 10 as a parameter will give you a peak at the contents of each file.

nodes<-read_csv("nodes.csv")
edges<-read_csv("edges.csv")
head(nodes,20)

head(edges,10)

Notice that the nodes have age, nationality, location, mentions (let us say this is number of times they appear in some source or collection of sources). I have also an arbitrary binary discuss column where I have manually flagged up a few important characters I might want to emphasise.

When preparing a collection of nodes and edges for network visualization it is usually best to have a column in the nodes table with unique id numbers that are used as a reference key to all other information about that agent. Then, in the edges table, you would see only the relevant id numbers, instead of the names. However, for this simple example, to increase the readability of the files as we learn the basics, I have chosen to use the given name the fictional individuals (there are just one or two real given names that fit the description of individuals for this network to add to the fun for East Asian historians) without any special id column.

Creating a Simple Network

Let us create a network object from our nodes and edges:

my_network=graph_from_data_frame(d=edges,directed=TRUE,vertices=nodes)

This creates an igraph network object, but it is a format that is easily understood by ggraph and most of its features. Later in this exercise we will convert this to a tidygraph tibble graph. For now, we can very easily create a simple graph diagram using the ggraph() command. It works in a very similar fashion to ggplot, which it is an expansion of. You tell it the network to use, assign a layout type, then add options. In this case we will simply add a geom_edge_link() which will give us the edges, and a geom_node_point() which will display points.

ggraph(my_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link() +
      # Add a node point geometry
      geom_node_point() 

This is very simple. We can see that it is placed on an x,y axis and looks like a kind of special ggplot diagram. There is lots of things we might want to do to improve this.

Adding Labels

Let us start by adding labels to the graph. Under geom_node_point() we will add a geom_node_label(). The aesthetics we will give it are to connect its label to the name column of our nodes, set the font face.

Then, back outside the aesthetics aes() we will set the transparency level to 60% (alpha=0.6). This may seem like somethign we would put inside the aesthetic, but because we are giving it a specific value, and not mapping it to our data, it goes outside. This will allow us to see any edge lines and nodes behind the label.

We also add the repel = TRUE here to help with the formatting of the location of the labels.

ggraph(my_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link() +
      # Add a node point geometry
      geom_node_point() +
    geom_node_label((aes(label = name, family="serif")), alpha=0.6, repel=TRUE)

Adding a Theme

Both ggplot and ggraph can work with “themes” that store lots of custom settings that we can apply to our graphs. You can store a theme in a function that calls the theme and then add that theme function to any graph you call. You might, for example, create several to match different purposes. See the R for Data Science book, or ggplot: Elegant Graphics for Data Analysis or the DataCamp class Communicating with Data in R (Tidyverse) or just run ?theme for more on themes.

Let us create a theme to use for our graphs. They will make the background a light grey, extend the margins, remove the axis text, ticks, and titles. It will also remove all the grid lines.

network_theme<- function() {
  theme(
    text=element_text(family="Times New Roman",face="bold"),
    plot.background = element_rect(fill="gray95"),
    plot.margin = unit(c(20,20,15,10), units="mm"),
    axis.text = element_blank(),
    axis.ticks = element_blank(),
    axis.title = element_blank(),
    panel.grid.major = element_blank(),
    panel.grid.minor = element_blank(),
    panel.background = element_blank()
  )
}

We need only call network_theme() at the end of our graphs to apply these settings.

Now in our next graph, notice the changes caused by our theme and no other changes:

ggraph(my_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link() +
      # Add a node point geometry
      geom_node_point() +
    geom_node_label((aes(label = name, family="serif")), alpha=0.6, repel = TRUE) +
    network_theme()

Adding Labels and More

Now let us begin adding some more things to our graph. Using the labs() function, we can add a title, a caption on the source of the data at the bottom right. Also in labs() we can rename the legend titles. Notice I use the escaped n character in one case to create a two line legend header. Notice that, in the case of the edge width, I had to use an “edge_” prefix before naming the legend header.

We’ll also make some other additions to our graph diagram. In the geom_edge_link() aesthetics, we will tell it to vary the width of the edgbe by the intensity column of our data. Then outside the aesthetics we will fix the color of the lines to a mid level grey.

We can control the scale of the width with the scale_edge_width() function, which sets the range to a minimum of 0.2 in width and a maximum of 2, scaling the numbers to something within that range.

For our nodes, our aes() now scales the size of the node by the number of mentions in the sources, and the color of the nodes according to the nationality.

ggraph(my_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(aes(width=intensity),colour="grey50") +
    # What happens when you change grey50 to grey20 or grey90? 
    scale_edge_width(range = c(0.2, 2.0)) +
      # Add a node point geometry
      geom_node_point(aes(size=mentions,color=nationality)) +
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Source\nMentions",
      color = "Nationality",
      edge_width = "Weight"
    ) +
    geom_node_label((aes(label = name, family="serif")), alpha=0.6, repel = TRUE) +
    network_theme()

Showing Direction with Arrows

We have a directed network. You can add arrows to the geom_edge_link() as below. Notice I also switched from width to transparency to show varying intensity and instead of showing nationality with node color, now show the gender.

ggraph(my_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(arrow = arrow(length = unit(1.5, 'mm')), 
                   end_cap = circle(1.3, 'mm'), aes(alpha = intensity)) +
    # What happens when you change the 1.5 in the length? or the 1.5 in the end_cap circle?
    scale_edge_width(range = c(0.2, 2.5), guide=FALSE) +
      # Add a node point geometry
      geom_node_point(aes(size=mentions,color=factor(gender))) +
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Source\nMentions",
      color = "Gender",
      edge_alpha = "Weight"
    ) +
    # Notice I used the edge_ prefix in order to give a legend title to the edge attribte
    geom_node_label((aes(label = name, family="serif")),alpha=0.6, repel = TRUE) +
    # Try changing geom_node_label to geom_node_text above. What happens?
    network_theme()

Creating a Subgraph by Filtering on an Edge attribute

One of the variables we have that we haven’t used is the kind column in the node data, which is a number from 1-3. What if we wanted to create a second diagram that only shows those relationships which are of kind 3?

The tidygraph library has a nice activate() method that allows you to manipulate nodes and edges or filter them in various ways. Instead of calling activate(edges) before manipulating edges, there is also a nice shortcut, with %E>% instead of the usual pipe or %N>% to work with your nodes. For this we need to take our igraph network and convert it to a tbl_graph with as_tbl_graph() and then we can use the filter() command to find just the edges which have a kind==3. If graphed this immediately, we would see the filtered edges, but also a number of isolated nodes no longer connected to the rest of the graph. We can activate the node layer and then filter out the isolated nodes with filter(!node_is_isolated()).

as_tbl_graph(my_network) %E>%
  filter(kind==3)  %N>%
  filter(!node_is_isolated()) %>%
  ggraph(layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(arrow = arrow(length = unit(1.5, 'mm')), 
                   end_cap = circle(1.5, 'mm'), aes(alpha = intensity)) +
    # What happens when you change the 1.5 in the length? or the 1.5 in the end_cap circle?
    scale_edge_width(range = c(0.2, 2.5), guide=FALSE) +
      # Add a node point geometry
      geom_node_point(aes(size=mentions,color=nationality)) +
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Source\nMentions",
      color = "Nationality",
      edge_alpha = "Weight"
    ) +
    # Notice I used the edge_ prefix in order to give a legend title to the edge attribte
    geom_node_label((aes(label = name, family="serif")), alpha=0.4, show.legend=FALSE, repel = TRUE) +
    # Try changing geom_node_label to geom_node_text above. What happens?
    network_theme()

Community Detection

Network scientists have developed a variety of algorithms to detect communities in a network. While the analytical value of this algorithmically derived grouping in the context of historical research may be limited, for larger networks, it can help you identify clusters to explore. For more on this read the chapter on “Subgroups” in the book A User’s Guide to Network Analysis in R. The tidygraph package inherits many of the community detection algorithms imbedded into igraph and makes them available to us, including Edge-betweenness (group_edge_betweenness), Leading eigenvector (group_leading_eigen), Fast-greedy (group_fast_greedy), Louvain (group_louvain), Walktrap (group_walktrap), Label propagation (group_label_prop), InfoMAP (group_infomap), Spinglass (group_spinglass), and Optimal (group_optimal). Some community algorithms are designed to take into account direction or weight, while others ignore it. Below we try Walktrap, which is not, in fact, designed for directed networks, but try comparing its results with other community detection algorithms and note the differences.

as_tbl_graph(my_network) %>% 
  to_undirected() %>%
  mutate(community = as.factor(group_walktrap())) %>% 
  ggraph(layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(aes(alpha = intensity), show.legend = FALSE) +
    # No longer need the arrow because we have made our graph undirected  
    scale_edge_width(range = c(0.2, 2.5), guide=FALSE) +
      geom_node_point(aes(size=mentions, color=community)) +
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Source\nMentions",
      color = "Community"
    ) +
    geom_node_label((aes(label = name)),family="serif",alpha=0.6, repel = TRUE) +
    network_theme()

Bimodal Networks

Bimodal, bipartite, or affiliation networks have two different types of nodes and generally only link between the two types of nodes. As the term “affiliation network” suggests, this is often in the form of the affiliation of an individual to an organisation of some kind.

Let us import a list of edges between individuals and organisations.

affiliations<-read_csv("org-edges.csv")
affiliations

We have now a table with relationships between indivdiuals and organisations, but it would be nice to create a merged node table which joins all the attribute information from organisations, which includes the location of the organisations’ headquarters, and all the attribute data for individuals. We can use full_join() for this.

# 
org_nodes<-read_csv("orgs.csv") # Orgs have a name, but also a HQ location

merged_nodes<-full_join(nodes,org_nodes,by = c("person" = "Name"))
merged_nodes

Now we can create a network object from this merged information. In order to keep track of what nodes are part of each mode (individuals or organisations) we’ll add a type column to the node data that will get a TRUE value if it is one of the organisations.

affiliation_network=graph_from_data_frame(d=affiliations,directed=FALSE,vertices=merged_nodes)
V(affiliation_network)$type<-V(affiliation_network)$name  %in% org_nodes$Name

Now we can great a graph diagram of our bimodal network. In the code, I have made a few customisations to our usual graphs above by setting the shape of the node to correspond to whether it is an individual or an organisation and then chose a circle (ggplot shape number 19) or a square (15). I increased the fig_width to make the chart wider, and used some conditionals in the form of ifelse() to conditionally distinguish the organisations by color, and only assign labels to individuals.

Note: If you run this code in R Studio, note the difference between the appearance of the plots within R Studio and the exported web page version.

ggraph(affiliation_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link() +
    geom_node_point(aes(size=type, shape=type, color=ifelse(type==1,as.character(name),NA))) +
    scale_color_discrete(breaks=unique(affiliations$To)) +
    scale_size_discrete(range=c(2,4), guide=FALSE) +
    scale_shape_manual(values=c(19,15), guide=FALSE) +  
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      shape = "Person or\nOrganization",
      color = "Organization"
    ) +
    geom_node_label((aes(label = ifelse(type==0,as.character(name),""))), family="serif", alpha=0.7, show.legend=FALSE, repel = TRUE) +
    network_theme()

You can also use a special bipartite layout for the graph that produces a hierarchical look. Sometimes the tree layout will also produce a desirable effect as well.

ggraph(affiliation_network, layout = "bipartite") +
      # Add an edge link geometry
      geom_edge_link() +
    geom_node_point(aes(size=type, shape=type, color=ifelse(type==1,as.character(name),NA))) +
    scale_color_discrete(breaks=unique(affiliations$To)) +
    scale_size_discrete(range=c(2,4), guide=FALSE) +
    scale_shape_manual(values=c(19,15), guide=FALSE) +  
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      shape = "Person or\nOrganization",
      color = "Organization"
    ) +
    geom_node_label((aes(label = ifelse(type==0,as.character(name),""))), family="serif", alpha=0.7, show.legend=FALSE, repel = TRUE) +
    network_theme()

Bimodal graphs are nice for visualising the connections between two different types of things. As Scott Weingart has argued in several web posts, including his overview of bimodal networks, they are significantly more difficult to analysis using formal network analysis methods, including the challenge of exploring various forms of centrality or clustering coefficients.

They are valuable, however, as a heuristic visualisation to explore your network and discover new questions, or areas to focus in on for more research. They can also serve more simple illustrative purposes when you are exploring a historical network in your narrative and want to illustrate visually relationships between individuals and organisations or some other combination of two modes even without formal analysis being carried out.

One useful transformation of your bimodal newtorks that can be particularly useful, especially for larger networks than the one we are dealing with here, is to explore connections between the nodes in one mode or the other by means of their connections to the other mode. In our historical example, we might explore what the connectivity is between organisations based on members who tie them together, or, what connections are there between individuals by virtue of the fact that they share membership in an organisation. These are called projections of bimodal networks.

To create these projections we can use the igraph function bipartite.projection() function. This will create a list with two projections proj1 and proj2, one for each mode. Let us assign each one to its own network object and then plot them.

network_projections<-bipartite.projection(affiliation_network)
member_projection<-network_projections$proj1
org_projection<-network_projections$proj2
ggraph(member_projection, layout = "kk") +
      geom_edge_link(aes(alpha=weight, width=weight)) +
    scale_edge_width(range = c(0.1, 1.5), name="Weight") +
    scale_edge_alpha(range = c(0.3, 1), guide=FALSE) +
    geom_node_point(size=3) +
    labs(
      title = "Toilers and Gangsters, 1860-1950: Bipartite Projection of Members",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      shape = "Person or\nOrganization",
      color = "Organization"
    ) +
    geom_node_label((aes(label = name)), family="serif", alpha=0.7, show.legend=FALSE, repel = TRUE) +
    network_theme()

ggraph(org_projection, layout = "kk") +
      geom_edge_link(aes(alpha=weight, width=weight)) +
    scale_edge_width(range = c(0.1, 1.5), name="Weight") +
    scale_edge_alpha(range = c(0.3, 1), guide=FALSE) +
    geom_node_point(size=3) +
    labs(
      title = "Toilers and Gangsters, 1860-1950: Bipartite Projection of Organisations",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      shape = "Person or\nOrganization",
      color = "Organization"
    ) +
    geom_node_label((aes(label = name)), family="serif", alpha=0.7, show.legend=FALSE, repel = TRUE) +
    network_theme()

The lines here are thicker in the cases where members were more linked to each other by mutual membership in multiple organisations. In the second plot we see that four of the organisations each share two members. Not terribly revealing in this case, but with much larger networks, this may reveal interlocking organisations with overlapping memberships that might not be immediately obvious by perusing a table of membership data.

One Plot to Rule Them All

Bimodal networks include only connections between two different modes. But there is nothing preventing you from flattening a bimodal graph and including all the edges from our unimodal network. That is, you can create a visualisation, for illustrative or heuristic purposes, that depicts both relationships between individuals and between these individuals and the organisations. Please note that if formal analysis plays any role in your exploration of these networks, this is not methodologically sound for any number of reasons. Among the issues is that we are mixing a directed network (of individuals) with an undirected network (of affiliations).

To create our mega plot, we will merge the edge table with relationships between individuals and organisations using bind_rows(), with that of individuals to individuals. For simplicity, we will first assign an intensity of 1 and type 4 to all affiliation relationships, and leave all date info as NA. We’ll also standardise the naming of the columns as “From” and “To” are capitalised in one case and not in the other. mutate() makes it easy to rename the columns.

We can then visualise all the edges together, and use various visual features to help make the plot more readable, but anyone who has used software such as Cytoscape, for example, will see that it is much easier to customise the visualisation of multiple networks together there than here, as far as I have been able to determine. Especially if the aim is just to explore your data as a part of the research and thinking process, then Cytoscape is a much easier alternative to R and igraph/ggraph.

prep<- affiliations %>%
  mutate(from=From,to=To,kind=4,intensity=1,year_start=NA,year_end=NA) %>%
  select(from,to,kind,intensity,year_start,year_end)
merged_edges<- bind_rows(edges,prep)
merged_edges

Now let us create a new network object with this merged edge table and our previously merged node table and plot the results:

fully_merged=graph_from_data_frame(d=merged_edges,directed=TRUE,vertices=merged_nodes)
V(fully_merged)$type<-V(fully_merged)$name  %in% org_nodes$Name

ggraph(fully_merged, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(aes(width=intensity)) +
    scale_edge_width(range=c(0.1,1.5), name="Intensity") +
    geom_node_point(aes(size=type, shape=type, color=ifelse(type==1,as.character(name),NA))) +
    scale_color_discrete(breaks=unique(affiliations$To)) +
    scale_size_discrete(range=c(2,4), guide=FALSE) +
    scale_shape_manual(values=c(19,15), guide=FALSE) +  
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      shape = "Person or\nOrganization",
      color = "Organization"
    ) +
    geom_node_label((aes(label = ifelse(type==0,as.character(name),""))), family="serif", alpha=0.7, show.legend=FALSE, repel = TRUE) +
    network_theme()

## Warning: Using size for a discrete variable is not advised.

Other Layouts

Up until now we have been mostly using the Kamada-Kawai layout algorithm to determine the look of our network. There are a range of the other layouts you can create with the replacement of the layout type.

Below see our graph with the Fruchterman-Reingold layout.

ggraph(my_network, layout = "fr") +
      # Add an edge link geometry
      geom_edge_link(arrow = arrow(length = unit(1.5, 'mm')), 
                   end_cap = circle(1.5, 'mm'), aes(alpha = intensity)) +
    # What happens when you change grey50 to grey20 or grey90? 
    scale_edge_width(range = c(0.2, 2.0)) +
      geom_node_point(aes(size=mentions,color=nationality)) +
    scale_size(range = c(2,10)) +
    labs(
      edge_width= "Weight",
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Source\nMentions",
      color = "Nationality",
      edge_width = "Weight"
    ) +
    geom_node_label((aes(label = name)), family="serif",alpha=0.6, show.legend=FALSE, repel = TRUE) +
    network_theme()

There is also a “circular” layout, which takes a bit more tweaking of the parameters and size to get it to fit well:

ggraph(my_network, layout = "linear",  circular = TRUE) + 
  geom_edge_arc(aes(width = intensity), alpha = 0.8) + 
  scale_edge_width(range = c(0.2, 1)) +
  geom_node_label(aes(label = name), size=2.2) +
  labs(edge_width = "Weight") +
  theme_graph() +
  theme(legend.position="bottom")

Adding Some Network Analysis

Although we have been using the ggraph package to visualise our network, the graph itself is an igraph object and can take advantage of all the analytical tools in igraph:

Look how easy it is to add columns, using our trusty dplyr mutate() to add columes with the betweenness, closeness, and eigenvector centrality computed for our nodes, together with the total, in, and out degrees.

nodes_analysis<- nodes %>% 
  mutate(between=betweenness(my_network, directed=FALSE),
         degree_all=degree(my_network,mode="all"),
         degree_in=degree(my_network,mode="in"),
         degree_out=degree(my_network,mode="out"),
         closeness=closeness(my_network),
         eigenvector=evcent(my_network)$vector)

Note: If your graph is in tidygraph you can also use the wide variety of centrality_ prefixed functions.

We can do a quick comparison of in, out and total degree of the nodes, which measures the outgoing and incoming relationships, or their total, minus any overlapping edges. Notice I used the fct_reorder() function from the forcats library to re-sort the names by their total degree (degree_all). Comment out that line to see what happens to the graph.

nodes_analysis %>%
  mutate(person = fct_reorder(person, degree_all)) %>%
  ggplot() +
    geom_point(aes(x=degree_in,y=person, color="In Degree")) + # , color="khaki2"
    geom_point(aes(x=degree_out,y=person, color="Out Degree")) + # , color="cadetblue3"
    geom_point(aes(x=degree_all,y=person,size=eigenvector, color="Total Degree")) + # ,color="darkslategrey"
  scale_size(range=c(0.3,4)) +
  labs(
        x = "In and Degree",
        y = "Name",
        color = "Degrees",
        title = "Degrees and Total Degrees with Eigenvector Centrality",
        subtitle = "As Seen in Toilers and Gangsters Network",
        caption = "Total degree is sum of in & out minus doubled counted edges.",
        size = "Eigenvector\nCentrality"
      )

With this data we could easily plot the relationship between various kinds of centrality. Betweenness centrality is a measure of the degree to which a node is a gatekeeper to other nodes. How many of the shortest paths between nodes must pass through a given node? Eigenvector centrality tries to judge the importance of a node by the relative connectivity of its neighbors. Read more about it here. Let us compare the two in our own network:

nodes_analysis %>%
  ggplot() +
    geom_point(aes(x=between,y=eigenvector,size=degree_all)) +
    labs(
        x = "Betweenness",
        y = "Eigenvector Centrality",
        title = "Relationship between Betweenness and Eigenvector Centrality ",
        subtitle = "As Seen in Toilers and Gangsters Network",
        size = "Node\nDegree"
      )

How about the relationship bewteen Eigenvector centrality and another measure, closeness centrality. Closeness centrality is a measure of how close a given node is to all the other nodes.

nodes_analysis %>%
  ggplot() +
    geom_point(aes(x=closeness,y=eigenvector,size=degree_all)) +
    labs(
        x = "Closeness Centrality",
        y = "Eigenvector Centrality",
        title = "Relationship between Closeness and Eigenvector Centrality ",
        subtitle = "As Seen in Toilers and Gangsters Network",
        size = "Node\nDegree"
      )

Now that we have all this information, we can also now redo our network graph using any of these measures. Let us get a network graph that incorporates all the new variables we had added to the node table:

my_analysed_network=graph_from_data_frame(d=edges,directed=TRUE,vertices=nodes_analysis)

For example, here is a graph diagram with the size of the node changed to indicate its betweenness.

ggraph(my_analysed_network, layout = "kk") +
      # Add an edge link geometry
      geom_edge_link(arrow = arrow(length = unit(1.5, 'mm')), 
                   end_cap = circle(1.5, 'mm'), aes(alpha = intensity)) +
    # What happens when you change the 1.5 in the length? or the 1.5 in the end_cap circle?
    scale_edge_width(range = c(0.2, 2.5), guide=FALSE) +
      # Add a node point geometry
      geom_node_point(aes(size=between,color=nationality)) +
    labs(
      title = "Toilers and Gangsters, 1860-1950",
      caption = "Data from the 'Toilers and Gangsters' public dataset",
      size = "Betweenness",
      color = "Nationality",
      edge_alpha = "Weight"
    ) +
    # Notice I used the edge_ prefix in order to give a legend title to the edge attribte
    geom_node_label((aes(label = name, family="serif")),alpha=0.6, repel = TRUE) +
    # Try changing geom_node_label to geom_node_text above. What happens?
    network_theme()

Books

Luke, Douglas A. A User’s Guide to Network Analysis in R. 1st ed. 2015 edition. Cham Hildesheim New York: Springer, 2015.

Wickham, Hadley. ggplot2: Elegant Graphics for Data Analysis. 2nd ed. 2016 edition. New York, NY: Springer, 2016.

Scott, John. Social Network Analysis. 3rd ed., 2013.

Scott, John, and Peter J. Carrington, eds. The SAGE Handbook of Social Network Analysis. London ; Thousand Oaks, Calif: SAGE, 2011.

Wasserman, Stanley, and Katherine Faust. Social Network Analysis: Methods and Applications. Cambridge University Press, 1994.

• Jesse Sadler’s Tutorial on ggraph - This tutorial is a wonderful alternative to what you have done here, and has the advantage of working on a real historical dataset. See also Jesse Sadler’s numerous other informative posts and tutorials.
• Douglas Luke’s A User’s Guide to Network Analysis in R - Uses statnet and igraph but also shows how to convert between them. Unfortunately, all plots are with base R plots, rather than ggplot.
• Network Science in R - A Tidy Approach - Massimo Franceschet’s course uses ggraph and igraph and makes use of more advanced approaches. See his useful collection of materials on his syllabus Dear Network Science
• Thomas Lin Pederson’s Blog - postings by the author of the ggraph package related to it.
• An Introduction to Ggraph
• Another Game of Thrones network analysis – this time with tidygraph and ggraph - A fun tutorial walking through the use og ggraph on the characters of this popular series.
• Katherine Ognyanova’s Fantastic igraph Overview - Really nice and extensive exploration of igraph features.
• igraph - The homepage and documentation for igraph on R. Also available on Python.
• Historical Network Research - An extensive bibliography. Especially good resource for looking at examples of historical scholarhip that use network science
• Awesome Network Analysis - Nice collection of books and resources.
• Using Metadata to Find Paul Revere - A fun way to introduce history lovers to the potential of SNA in historical research.
• “Demystifying Networks” - A classic introduction from Scott Weingart, see also several posts in this series.
• Miriam Posner’s Glossary of Social Network Analysis - See also Miriam Posner’s cytoscape tutorials which are the best out there for using cytoscape in the humanities.
• If Everything is a Network, Nothing is a Network by Mushon Zer-Aviv

This R Notebook was written with the help of various books and tutorials mentioned above, but mostly thanks to 40-60 google searches, with the answers found generally on the websites above, Stack Overflow, and obscure online bulletin boards.